/**
  * @name Usage of APIs coming from external libraries
  * @description A list of 3rd party APIs used in the codebase. Excludes test and generated code.
  * @tags telemetry
  * @id xyz
  */
 
  private import java
  private import semmle.code.java.dataflow.DataFlow
  private import semmle.code.java.dataflow.ExternalFlow
  private import semmle.code.java.dataflow.FlowSources
  private import semmle.code.java.dataflow.FlowSummary
  private import semmle.code.java.dataflow.internal.DataFlowPrivate
  private import semmle.code.java.dataflow.internal.FlowSummaryImpl as FlowSummaryImpl
  private import semmle.code.java.dataflow.TaintTracking
  
  pragma[nomagic]
  private predicate isTestPackage(Package p) {
    p.getName()
        .matches([
            "org.junit%", "junit.%", "org.mockito%", "org.assertj%",
            "com.github.tomakehurst.wiremock%", "org.hamcrest%", "org.springframework.test.%",
            "org.springframework.mock.%", "org.springframework.boot.test.%", "reactor.test%",
            "org.xmlunit%", "org.testcontainers.%", "org.opentest4j%", "org.mockserver%",
            "org.powermock%", "org.skyscreamer.jsonassert%", "org.rnorth.visibleassertions",
            "org.openqa.selenium%", "com.gargoylesoftware.htmlunit%", "org.jboss.arquillian.testng%",
            "org.testng%"
          ])
  }
  
  /**
   * A test library.
   */
  private class TestLibrary extends RefType {
    TestLibrary() { isTestPackage(this.getPackage()) }
  }
  
  /** Holds if the given callable is not worth supporting. */
  private predicate isUninteresting(Callable c) {
    c.getDeclaringType() instanceof TestLibrary or
    c.(Constructor).isParameterless()
  }
  
  /**
   * An external API from either the Standard Library or a 3rd party library.
   */
  class ExternalApi extends Callable {
    ExternalApi() { not this.fromSource() and not isUninteresting(this) }
  
    /**
     * Gets information about the external API in the form expected by the MaD modeling framework.
     */
    string getApiName() {
      result =
        this.getDeclaringType().getPackage() + "." + this.getDeclaringType().getSourceDeclaration() +
          "#" + this.getName() + paramsString(this)
    }
  
  
    /** Gets a node that is an input to a call to this API. */
    private DataFlow::Node getAnInput() {
      exists(Call call | call.getCallee().getSourceDeclaration() = this |
        result.asExpr().(Argument).getCall() = call or
        result.(ArgumentNode).getCall().asCall() = call
      )
    }
  
    /** Gets a node that is an output from a call to this API. */
    private DataFlow::Node getAnOutput() {
      exists(Call call | call.getCallee().getSourceDeclaration() = this |
        result.asExpr() = call or
        result.(DataFlow::PostUpdateNode).getPreUpdateNode().(ArgumentNode).getCall().asCall() = call
      )
    }
  
    /** Holds if this API has a supported summary. */
    pragma[nomagic]
    predicate hasSummary() {
      this = any(SummarizedCallable sc).asCallable() or
      TaintTracking::localAdditionalTaintStep(this.getAnInput(), _)
    }
  
    pragma[nomagic]
    predicate isSource() {
      this.getAnOutput() instanceof RemoteFlowSource or sourceNode(this.getAnOutput(), _)
    }
  
    /** Holds if this API is a known sink. */
    pragma[nomagic]
    predicate isSink() { sinkNode(this.getAnInput(), _) }
  
    /** Holds if this API is a known neutral. */
    pragma[nomagic]
    predicate isNeutral() { this = any(FlowSummaryImpl::Public::NeutralCallable nsc).asCallable() }
  
    /**
     * Holds if this API is supported by existing CodeQL libraries, that is, it is either a
     * recognized source, sink or neutral or it has a flow summary.
     */
    predicate isSupported() {
      this.hasSummary() or this.isSource() or this.isSink() or this.isNeutral()
    }
  }
  
 private Call aUsage(ExternalApi api) {
    result.getCallee().getSourceDeclaration() = api and
    not result.getFile() instanceof GeneratedFile
  }
  
  private boolean isSupported(ExternalApi api) {
   api.isSupported() and result = true
   or
   not api.isSupported() and
   result = false
  }
  
  from ExternalApi api, string apiName, boolean supported, Call usage
  where
    apiName = api.getApiName() and
    supported = isSupported(api) and
    usage = aUsage(api)
  select apiName, supported, usage